1. Technical Field
This invention generally relates to computer systems that execute multiple processes from a shared instruction stream, and more specifically relates to the handling of debugger breakpoints in such computer systems.
2. Background Art
Computer systems have evolved into extremely sophisticated devices, and may be found in many different settings. Computer systems typically include a combination of hardware, such as semiconductors and circuit boards, and software, also known as computer programs. As advances in semiconductor processing and computer architecture push the performance of the computer hardware higher, more sophisticated computer software has evolved to take advantage of the higher performance of the hardware, resulting in computer systems today that are much more powerful than just a few years ago.
As the sophistication and complexity of computer software increase, the more difficult the software is to debug. Debugging is the process of finding problems, or “bugs”, during the development of a computer program. Most modern programming environments include a debugger that provides tools for testing and debugging a computer program.
Known debuggers allow the programmer to set one or more breakpoints in the computer program, which are points where the execution of the computer program is stopped so that the state of the program can be examined to verify that the program executed as designed. Breakpoints may be hardware breakpoints or software breakpoints. A software breakpoint is set at a particular instruction by replacing the instruction with a trap instruction that causes control of the program to be passed to the debugger when the trap instruction is executed. This works well when a single process executes an instruction stream. However, if multiple processes execute a shared instruction stream, setting a breakpoint at an instruction can cause all processes that execute the shared instruction stream to break at that instruction. If only one of the processes needs a breakpoint at the trap instruction, and especially if debugging the one process is best done with other processes running without encountering breakpoints, simply writing a trap instruction to the shared instruction stream is not a desirable solution. Without a way to create a breakpoint for one process in a system with multiple processes that execute a shared instruction stream without causing other processes to also break, the debugging of such computer systems will be impaired.